package cn.iocoder.yudao.module.trade.order.mq;

import cn.hutool.core.util.StrUtil;
import cn.hutool.extra.spring.SpringUtil;
import cn.iocoder.yudao.module.api.dine.message.DinePrintedMessage;
import cn.iocoder.yudao.module.api.pay.order.message.PayCloseMessage;
import cn.iocoder.yudao.module.api.pay.order.message.PayExpireMessage;
import cn.iocoder.yudao.module.api.pay.order.message.PaySuccessMessage;
import cn.iocoder.yudao.module.api.pay.refund.message.RefundFailureMessage;
import cn.iocoder.yudao.module.api.pay.refund.message.RefundSuccessMessage;
import cn.iocoder.yudao.module.api.trade.ConfigConstants;
import cn.iocoder.yudao.module.trade.order.service.TradeOrderAcceptService;
import cn.iocoder.yudao.module.trade.order.service.TradeOrderUpdateService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

/**
 * 交易订单的消费者
 *
 * @author 山野羡民
 */
@Component
@Slf4j
public class TradeOrderConsumer {

    @EventListener
    @Async // Spring Event 默认在 Producer 发送的线程，通过 @Async 实现异步
    public void onMessage(PaySuccessMessage message) {
        log.info("[trade][onMessage][支付成功({})]", message);
        if (!StrUtil.startWith(message.getTradeNo(), ConfigConstants.TRADE_ORDER_NO_PREFIX)) {
            log.debug("[trade][onMessage][不是产品交易订单({})，忽略付款成功事件]", message.getTradeNo());
            return;
        }
        SpringUtil.getBean(TradeOrderUpdateService.class).updateOrderPaid(message.getTradeNo(), message.getPayNo());
    }

    @EventListener
    @Async // Spring Event 默认在 Producer 发送的线程，通过 @Async 实现异步
    public void onMessage(PayCloseMessage message) {
        log.info("[trade][onMessage][支付关闭({})]", message);
        if (!StrUtil.startWith(message.getTradeNo(), ConfigConstants.TRADE_ORDER_NO_PREFIX)) {
            log.debug("[trade][onMessage][不是产品交易订单({})，忽略支付关闭事件]", message.getTradeNo());
            return;
        }
        SpringUtil.getBean(TradeOrderUpdateService.class).updateOrderExpired(message.getTradeNo());
    }

    @EventListener
    @Async // Spring Event 默认在 Producer 发送的线程，通过 @Async 实现异步
    public void onMessage(PayExpireMessage message) {
        log.info("[trade][onMessage][付款超时({})]", message);
        if (!StrUtil.startWith(message.getTradeNo(), ConfigConstants.TRADE_ORDER_NO_PREFIX)) {
            log.debug("[trade][onMessage][不是产品交易订单({})，忽略付款超时事件]", message.getTradeNo());
            return;
        }
        SpringUtil.getBean(TradeOrderUpdateService.class).updateOrderExpired(message.getTradeNo());
    }

    @EventListener
    @Async // Spring Event 默认在 Producer 发送的线程，通过 @Async 实现异步
    public void onMessage(RefundSuccessMessage message) {
        log.info("[trade][onMessage][退款成功({})]", message);
        SpringUtil.getBean(TradeOrderUpdateService.class).updateOrderRefunded(message.getRefundNo());
    }

    @EventListener
    @Async // Spring Event 默认在 Producer 发送的线程，通过 @Async 实现异步
    public void onMessage(RefundFailureMessage message) {
        log.info("[trade][onMessage][退款失败({})]", message);
        SpringUtil.getBean(TradeOrderUpdateService.class).updateOrderRefunded(message.getRefundNo());
    }

    @EventListener
    @Async // Spring Event 默认在 Producer 发送的线程，通过 @Async 实现异步
    public void onMessage(DinePrintedMessage message) {
        log.info("[trade][onMessage][订单小票打印完成事件({})]", message.getTradeNo());
        if (!StrUtil.startWith(message.getTradeNo(), ConfigConstants.TRADE_ORDER_NO_PREFIX)) {
            log.debug("[trade][onMessage][不是产品交易订单({})，忽略小票打印完成事件]", message.getTradeNo());
            return;
        }
        SpringUtil.getBean(TradeOrderAcceptService.class).acceptOrderWhenPrintSuccess(message.getTradeNo());
    }

}
